Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

-12(I1(x), I1(y)) -> O11(-2(x, y))
SIZE1(N3(x, l, r)) -> +12(Size1(l), Size1(r))
+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
BS11(N3(x, l, r)) -> AND2(ge2(x, Max1(l)), ge2(Min1(r), x))
BS11(N3(x, l, r)) -> MAX1(l)
WB11(N3(x, l, r)) -> GE2(Size1(l), Size1(r))
GE2(0, O1(x)) -> GE2(0, x)
SIZE1(N3(x, l, r)) -> SIZE1(l)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
WB11(N3(x, l, r)) -> AND2(WB1(l), WB1(r))
GE2(I1(x), I1(y)) -> GE2(x, y)
LOG'1(O1(x)) -> +12(Log'1(x), I1(0))
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
+12(x, +2(y, z)) -> +12(x, y)
WB11(N3(x, l, r)) -> SIZE1(l)
WB11(N3(x, l, r)) -> WB11(r)
-12(I1(x), I1(y)) -> -12(x, y)
LOG'1(O1(x)) -> LOG'1(x)
-12(I1(x), O1(y)) -> -12(x, y)
+12(I1(x), I1(y)) -> O11(+2(+2(x, y), I1(0)))
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
SIZE1(N3(x, l, r)) -> +12(+2(Size1(l), Size1(r)), I1(1))
WB11(N3(x, l, r)) -> AND2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))
BS11(N3(x, l, r)) -> BS11(l)
WB11(N3(x, l, r)) -> -12(Size1(r), Size1(l))
WB11(N3(x, l, r)) -> -12(Size1(l), Size1(r))
BS11(N3(x, l, r)) -> GE2(Min1(r), x)
SIZE1(N3(x, l, r)) -> SIZE1(r)
LOG'1(I1(x)) -> +12(Log'1(x), I1(0))
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
WB11(N3(x, l, r)) -> IF3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l))))
GE2(O1(x), I1(y)) -> NOT1(ge2(y, x))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(r), Size1(l)))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(l), Size1(r)))
LOG'1(O1(x)) -> GE2(x, I1(0))
LOG1(x) -> -12(Log'1(x), I1(0))
BS11(N3(x, l, r)) -> BS11(r)
LOG1(x) -> LOG'1(x)
BS11(N3(x, l, r)) -> AND2(BS1(l), BS1(r))
BS11(N3(x, l, r)) -> AND2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
+12(O1(x), O1(y)) -> O11(+2(x, y))
BS11(N3(x, l, r)) -> MIN1(r)
GE2(O1(x), O1(y)) -> GE2(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
WB11(N3(x, l, r)) -> WB11(l)
WB11(N3(x, l, r)) -> SIZE1(r)
BS11(N3(x, l, r)) -> GE2(x, Max1(l))
LOG'1(O1(x)) -> IF3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
-12(O1(x), O1(y)) -> O11(-2(x, y))
MAX1(N3(x, l, r)) -> MAX1(r)
LOG'1(I1(x)) -> LOG'1(x)
MIN1(N3(x, l, r)) -> MIN1(l)
+12(O1(x), O1(y)) -> +12(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

-12(I1(x), I1(y)) -> O11(-2(x, y))
SIZE1(N3(x, l, r)) -> +12(Size1(l), Size1(r))
+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
BS11(N3(x, l, r)) -> AND2(ge2(x, Max1(l)), ge2(Min1(r), x))
BS11(N3(x, l, r)) -> MAX1(l)
WB11(N3(x, l, r)) -> GE2(Size1(l), Size1(r))
GE2(0, O1(x)) -> GE2(0, x)
SIZE1(N3(x, l, r)) -> SIZE1(l)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
WB11(N3(x, l, r)) -> AND2(WB1(l), WB1(r))
GE2(I1(x), I1(y)) -> GE2(x, y)
LOG'1(O1(x)) -> +12(Log'1(x), I1(0))
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
+12(x, +2(y, z)) -> +12(x, y)
WB11(N3(x, l, r)) -> SIZE1(l)
WB11(N3(x, l, r)) -> WB11(r)
-12(I1(x), I1(y)) -> -12(x, y)
LOG'1(O1(x)) -> LOG'1(x)
-12(I1(x), O1(y)) -> -12(x, y)
+12(I1(x), I1(y)) -> O11(+2(+2(x, y), I1(0)))
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
SIZE1(N3(x, l, r)) -> +12(+2(Size1(l), Size1(r)), I1(1))
WB11(N3(x, l, r)) -> AND2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))
BS11(N3(x, l, r)) -> BS11(l)
WB11(N3(x, l, r)) -> -12(Size1(r), Size1(l))
WB11(N3(x, l, r)) -> -12(Size1(l), Size1(r))
BS11(N3(x, l, r)) -> GE2(Min1(r), x)
SIZE1(N3(x, l, r)) -> SIZE1(r)
LOG'1(I1(x)) -> +12(Log'1(x), I1(0))
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
WB11(N3(x, l, r)) -> IF3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l))))
GE2(O1(x), I1(y)) -> NOT1(ge2(y, x))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(r), Size1(l)))
WB11(N3(x, l, r)) -> GE2(I1(0), -2(Size1(l), Size1(r)))
LOG'1(O1(x)) -> GE2(x, I1(0))
LOG1(x) -> -12(Log'1(x), I1(0))
BS11(N3(x, l, r)) -> BS11(r)
LOG1(x) -> LOG'1(x)
BS11(N3(x, l, r)) -> AND2(BS1(l), BS1(r))
BS11(N3(x, l, r)) -> AND2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
+12(O1(x), O1(y)) -> O11(+2(x, y))
BS11(N3(x, l, r)) -> MIN1(r)
GE2(O1(x), O1(y)) -> GE2(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
WB11(N3(x, l, r)) -> WB11(l)
WB11(N3(x, l, r)) -> SIZE1(r)
BS11(N3(x, l, r)) -> GE2(x, Max1(l))
LOG'1(O1(x)) -> IF3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
-12(O1(x), O1(y)) -> O11(-2(x, y))
MAX1(N3(x, l, r)) -> MAX1(r)
LOG'1(I1(x)) -> LOG'1(x)
MIN1(N3(x, l, r)) -> MIN1(l)
+12(O1(x), O1(y)) -> +12(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 5 SCCs with 38 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE2(0, O1(x)) -> GE2(0, x)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


GE2(0, O1(x)) -> GE2(0, x)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
GE2(x1, x2)  =  GE1(x2)
0  =  0
O1(x1)  =  O1(x1)

Lexicographic Path Order [19].
Precedence:
[0, O1] > GE1


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

GE2(I1(x), I1(y)) -> GE2(x, y)
GE2(I1(x), O1(y)) -> GE2(x, y)
GE2(O1(x), I1(y)) -> GE2(y, x)
GE2(O1(x), O1(y)) -> GE2(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-12(I1(x), I1(y)) -> -12(x, y)
-12(I1(x), O1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


-12(I1(x), O1(y)) -> -12(x, y)
-12(O1(x), O1(y)) -> -12(x, y)
The remaining pairs can at least by weakly be oriented.

-12(I1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
Used ordering: Combined order from the following AFS and order.
-12(x1, x2)  =  -11(x2)
I1(x1)  =  x1
O1(x1)  =  O1(x1)
-2(x1, x2)  =  -
1  =  1
0  =  0

Lexicographic Path Order [19].
Precedence:
[-^11, -] > 0 > [O1, 1]


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-12(I1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


-12(I1(x), I1(y)) -> -12(x, y)
-12(O1(x), I1(y)) -> -12(x, y)
The remaining pairs can at least by weakly be oriented.

-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
Used ordering: Combined order from the following AFS and order.
-12(x1, x2)  =  -11(x2)
I1(x1)  =  I1(x1)
O1(x1)  =  O
-2(x1, x2)  =  -1(x2)
1  =  1
0  =  0

Lexicographic Path Order [19].
Precedence:
-^11 > I1 > -1 > [O, 1]
0 > [O, 1]


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ QDPOrderProof
          ↳ QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


-12(O1(x), I1(y)) -> -12(-2(x, y), I1(1))
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
-12(x1, x2)  =  x1
O1(x1)  =  O1(x1)
I1(x1)  =  I1(x1)
-2(x1, x2)  =  x1
1  =  1
0  =  0

Lexicographic Path Order [19].
Precedence:
[O1, I1] > 0
1 > 0


The following usable rules [14] were oriented:

-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
O1(0) -> 0



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
                  ↳ QDP
                    ↳ QDPOrderProof
QDP
                        ↳ PisEmptyProof
          ↳ QDP
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+12(I1(x), O1(y)) -> +12(x, y)
+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(x, +2(y, z)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
+12(O1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


+12(I1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(x, y)
+12(O1(x), O1(y)) -> +12(x, y)
+12(x, +2(y, z)) -> +12(+2(x, y), z)
The remaining pairs can at least by weakly be oriented.

+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(I1(x), I1(y)) -> +12(x, y)
Used ordering: Combined order from the following AFS and order.
+12(x1, x2)  =  +11(x2)
I1(x1)  =  x1
O1(x1)  =  O1(x1)
+2(x1, x2)  =  +2(x1, x2)
0  =  0

Lexicographic Path Order [19].
Precedence:
+^11 > +2 > 0
O1 > +2 > 0


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
+12(I1(x), I1(y)) -> +12(x, y)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


+12(O1(x), I1(y)) -> +12(x, y)
+12(I1(x), I1(y)) -> +12(x, y)
The remaining pairs can at least by weakly be oriented.

+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))
Used ordering: Combined order from the following AFS and order.
+12(x1, x2)  =  x2
O1(x1)  =  O1(x1)
I1(x1)  =  I1(x1)
+2(x1, x2)  =  +1(x2)
0  =  0

Lexicographic Path Order [19].
Precedence:
[I1, +1] > O1 > 0


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+12(I1(x), I1(y)) -> +12(+2(x, y), I1(0))

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
QDP
            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

LOG'1(O1(x)) -> LOG'1(x)
LOG'1(I1(x)) -> LOG'1(x)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


LOG'1(I1(x)) -> LOG'1(x)
The remaining pairs can at least by weakly be oriented.

LOG'1(O1(x)) -> LOG'1(x)
Used ordering: Combined order from the following AFS and order.
LOG'1(x1)  =  LOG'1(x1)
O1(x1)  =  x1
I1(x1)  =  I1(x1)

Lexicographic Path Order [19].
Precedence:
trivial


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

LOG'1(O1(x)) -> LOG'1(x)

The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be strictly oriented and are deleted.


LOG'1(O1(x)) -> LOG'1(x)
The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
LOG'1(x1)  =  LOG'1(x1)
O1(x1)  =  O1(x1)

Lexicographic Path Order [19].
Precedence:
O1 > LOG'1


The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

O1(0) -> 0
+2(0, x) -> x
+2(x, 0) -> x
+2(O1(x), O1(y)) -> O1(+2(x, y))
+2(O1(x), I1(y)) -> I1(+2(x, y))
+2(I1(x), O1(y)) -> I1(+2(x, y))
+2(I1(x), I1(y)) -> O1(+2(+2(x, y), I1(0)))
+2(x, +2(y, z)) -> +2(+2(x, y), z)
-2(x, 0) -> x
-2(0, x) -> 0
-2(O1(x), O1(y)) -> O1(-2(x, y))
-2(O1(x), I1(y)) -> I1(-2(-2(x, y), I1(1)))
-2(I1(x), O1(y)) -> I1(-2(x, y))
-2(I1(x), I1(y)) -> O1(-2(x, y))
not1(true) -> false
not1(false) -> true
and2(x, true) -> x
and2(x, false) -> false
if3(true, x, y) -> x
if3(false, x, y) -> y
ge2(O1(x), O1(y)) -> ge2(x, y)
ge2(O1(x), I1(y)) -> not1(ge2(y, x))
ge2(I1(x), O1(y)) -> ge2(x, y)
ge2(I1(x), I1(y)) -> ge2(x, y)
ge2(x, 0) -> true
ge2(0, O1(x)) -> ge2(0, x)
ge2(0, I1(x)) -> false
Log'1(0) -> 0
Log'1(I1(x)) -> +2(Log'1(x), I1(0))
Log'1(O1(x)) -> if3(ge2(x, I1(0)), +2(Log'1(x), I1(0)), 0)
Log1(x) -> -2(Log'1(x), I1(0))
Val1(L1(x)) -> x
Val1(N3(x, l, r)) -> x
Min1(L1(x)) -> x
Min1(N3(x, l, r)) -> Min1(l)
Max1(L1(x)) -> x
Max1(N3(x, l, r)) -> Max1(r)
BS1(L1(x)) -> true
BS1(N3(x, l, r)) -> and2(and2(ge2(x, Max1(l)), ge2(Min1(r), x)), and2(BS1(l), BS1(r)))
Size1(L1(x)) -> I1(0)
Size1(N3(x, l, r)) -> +2(+2(Size1(l), Size1(r)), I1(1))
WB1(L1(x)) -> true
WB1(N3(x, l, r)) -> and2(if3(ge2(Size1(l), Size1(r)), ge2(I1(0), -2(Size1(l), Size1(r))), ge2(I1(0), -2(Size1(r), Size1(l)))), and2(WB1(l), WB1(r)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.